Fault-Tolerant Consensus in Unknown and Anonymous Networks

This paper investigates under which conditions information can be reliably shared and consensus can be solved in unknown and anonymous message-passing networks that suffer from crash-failures. We provide algorithms to emulate registers and solve consensus under different synchrony assumptions. For this, we introduce a novel pseudo leader-election approach which allows a leader-based consensus implementation without breaking symmetry

Wait-Freedom with Advice

We motivate and propose a new way of thinking about failure detectors which allows us to define, quite surprisingly, what it means to solve a distributed task \emph{wait-free} \emph{using a failure detector}. In our model, the system is composed of \emph{computation} processes that obtain inputs and are supposed to output in a finite number of steps and \emph{synchronization} processes that are subject to failures and can query a failure detector. We assume that, under the condition that \emph{correct} synchronization processes take sufficiently many steps, they provide the computation processes with enough \emph{advice} to solve the given task wait-free: every computation process outputs in a finite number of its own steps, regardless of the behavior of other computation processes. Every task can thus be characterized by the \emph{weakest} failure detector that allows for solving it, and we show that every such failure detector captures a form of set agreement. We then obtain a complete classification of tasks, including ones that evaded comprehensible characterization so far, such as renaming or weak symmetry breaking

On the Space Complexity of Set Agreement

The $k$-set agreement problem is a generalization of the classical consensus problem in which processes are permitted to output up to $k$ different input values. In a system of $n$ processes, an $m$-obstruction-free solution to the problem requires termination only in executions where the number of processes taking steps is eventually bounded by $m$. This family of progress conditions generalizes wait-freedom ($m=n$) and obstruction-freedom ($m=1$). In this paper, we prove upper and lower bounds on the number of registers required to solve $m$-obstruction-free $k$-set agreement, considering both one-shot and repeated formulations. In particular, we show that repeated $k$ set agreement can be solved using $n+2m-k$ registers and establish a nearly matching lower bound of $n+m-k$

A separation of (n -1)-consensus and n-consensus in read-write shared-memory systems

A fundamental research theme in distributed computing is the comparison of systems in terms of their ability to solve basic problems such as consensus that cannot be solved in completely asynchronous systems. In particular, in a seminal work [14], Herlihy compares shared-memory systems in terms of the shared objects that they have: he proved that there are shared objects that are powerful enough to solve consensus among n processes, but are too weak to solve consensus among n + 1 processes; such objects are placed at level n of a wait-free hierarchy. The importance of this hierarchy comes from Herlihy's universality result: intuitively, every object at level n of this hierarchy can be used to implement any object shared by n processes in a wait-free manner. As in [14], we compare shared-memory systems with respect to their ability to solve consensus among n processes. But instead of comparing systems defined by the shared objects that they have, we compare readwrite systems defined by the process schedules that they allow. These systems capture a large set of systems, e.g., systems whose synchrony ranges from fully synchronous to completely asynchronous, several systems with failure detectors, and "obstruction-free" systems. In this paper, we consider read-write systems defined in terms of process schedules, and investigate the following natural question: For every n, is there a system of n processes that is strong enough to solve consensus among every subset of n -1 processes in the system, but not enough to solve consensus among all the n processes of the system? We show that the answer to the above question is "yes", and so these systems can be classified into hierarchy akin to Herlihy's hierarchy

Using Failure Detection and Consensus in the General Omission Failure Model to Solve Security Problems

It has recently been shown that fair exchange, a security problem in distributed systems, can be reduced to a fault tolerance problem, namely a special form of distributed consensus. The reduction uses the concept of security modules which reduce the type and nature of adversarial behavior to two standard fault-assumptions: message omission and process crash. In this paper, we investigate the feasibility of solving consensus in asynchronous systems in which crash and message omission faults may occur. Due to the impossibility result of consensus in such systems, following the lines of unreliable failure detectors of Chandra and Toueg, we add to the system a distributed device that gives information about the failure of other processes. Then we give an algorithm using this device to solve the consensus problem. Finally, we show how to implement such a device in a asynchronous untrusted environment using security modules and some weak timing assumptions

Set-Consensus Collections are Decidable

A natural way to measure the power of a distributed-computing model is to characterize the set of tasks that can be solved in it. In general, however, the question of whether a given task can be solved in a given model is undecidable, even if we only consider the wait-free shared-memory model. In this paper, we address this question for restricted classes of models and tasks. We show that the question of whether a collection C of (l, j)-set consensus objects, for various l (the number of processes that can invoke the object) and j (the number of distinct outputs the object returns), can be used by n processes to solve wait-free k-set consensus is decidable. Moreover, we provide a simple O(n^2) decision algorithm, based on a dynamic programming solution to the Knapsack optimization problem. We then present an adaptive wait-free set-consensus algorithm that, for each set of participating processes, achieves the best level of agreement that is possible to achieve using C. Overall, this gives us a complete characterization of a read-write model defined by a collection of set-consensus objects through its set-consensus power

Secretive Birds: Privacy in Population Protocols

We study private computations in a system of tiny mobile agents. We consider the mobile population protocol model of Angluin et al. and ask what can be computed without ever revealing any input to a curious adversary. We show that any predicate that can be computed in the original population model can be made private through an procedure that exploits the inherent non-determinism of the mobility pattern. In short, the idea is for every mobile agent to generate, besides its actual input value, a set of wrong input values to confuse the curious adversary. To converge to the correct result, the procedure has the agents eventually eliminate the wrong values; however, the moment when this happens i s hidden from the adversary. This is achieved without jeopardizing the tiny nature of the agents: they still have very small storage size that is independent of the cardinality of the system. We present three variants of this obfuscation procedure that help compute resp ectively, remainder, threshold, and or predicates which, when com posed, cover all those that can be computed in the population protocol model

When Birds Die: Making Population Protocols Fault-Tolerant

14 pagesIn the population protocol model introduced by Angluin et al., a collection of agents, which are modelled by finite state machines, move around unpredictably and have pairwise interactions. The ability of such systems to compute functions on a multiset of inputs that are initially distributed across all of the agents has been studied in the absence of failures. Here, we show that essentially the same set of functions can be computed in the presence of halting and transient failures, unless the number of failures is so large that they can immediately obscure enough of the inputs to change the outcome. We do this by giving a general-purpose transformation that makes any algorithm for the fault-free setting tolerant to failures

Asynchronous Consensus with Bounded Memory.

International audienceWe present here a bounded memory size Obstruction-Free consensus algorithm for the asynchronous shared memory model. More precisely for a set of n processes, this algorithm uses n+2n+2 multi-writer multi-reader registers, each of these registers being of size O(log(n))O(log⁡(n)) bits. From this, we get a bounded memory size space complexity consensus algorithm with single-writer multi-reader registers and a bounded memory size space complexity consensus algorithm in the asynchronous message passing model with a majority of correct processes. As it is easy to ensure the Obstruction-Free assumption with randomization (or with leader election failure detector ΩΩ) we obtain a bounded memory size randomized consensus algorithm and a bounded memory size consensus algorithm with failure detector